
layui.define(['store'],function(exports){

	/* axios v0.21.0 | (c) 2020 by Matt Zabriskie */
	(function webpackUniversalModuleDefinition(root, factory) {
		if(typeof exports === 'object' && typeof module === 'object')
			module.exports = factory();
		else if(typeof define === 'function' && define.amd)
			define([], factory);
		else if(typeof exports === 'object')
			exports["axios"] = factory();
		else
			root["axios"] = factory();
	})(this, function() {
		return /******/ (function(modules) { // webpackBootstrap
			/******/ 	// The module cache
			/******/ 	var installedModules = {};
			/******/
			/******/ 	// The require function
			/******/ 	function __webpack_require__(moduleId) {
				/******/
				/******/ 		// Check if module is in cache
				/******/ 		if(installedModules[moduleId])
					/******/ 			return installedModules[moduleId].exports;
				/******/
				/******/ 		// Create a new module (and put it into the cache)
				/******/ 		var module = installedModules[moduleId] = {
					/******/ 			exports: {},
					/******/ 			id: moduleId,
					/******/ 			loaded: false
					/******/ 		};
				/******/
				/******/ 		// Execute the module function
				/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
				/******/
				/******/ 		// Flag the module as loaded
				/******/ 		module.loaded = true;
				/******/
				/******/ 		// Return the exports of the module
				/******/ 		return module.exports;
				/******/ 	}
			/******/
			/******/
			/******/ 	// expose the modules object (__webpack_modules__)
			/******/ 	__webpack_require__.m = modules;
			/******/
			/******/ 	// expose the module cache
			/******/ 	__webpack_require__.c = installedModules;
			/******/
			/******/ 	// __webpack_public_path__
			/******/ 	__webpack_require__.p = "";
			/******/
			/******/ 	// Load entry module and return exports
			/******/ 	return __webpack_require__(0);
			/******/ })
			/************************************************************************/
			/******/ ([
				/* 0 */
				/***/ (function(module, exports, __webpack_require__) {

					module.exports = __webpack_require__(1);

					/***/ }),
				/* 1 */
				/***/ (function(module, exports, __webpack_require__) {

					'use strict';

					var utils = __webpack_require__(2);
					var bind = __webpack_require__(3);
					var Axios = __webpack_require__(4);
					var mergeConfig = __webpack_require__(22);
					var defaults = __webpack_require__(10);

					/**
					 * Create an instance of Axios
					 *
					 * @param {Object} defaultConfig The default config for the instance
					 * @return {Axios} A new instance of Axios
					 */
					function createInstance(defaultConfig) {
						var context = new Axios(defaultConfig);
						var instance = bind(Axios.prototype.request, context);

						// Copy axios.prototype to instance
						utils.extend(instance, Axios.prototype, context);

						// Copy context to instance
						utils.extend(instance, context);

						return instance;
					}

					// Create the default instance to be exported
					var axios = createInstance(defaults);

					// Expose Axios class to allow class inheritance
					axios.Axios = Axios;

					// Factory for creating new instances
					axios.create = function create(instanceConfig) {
						return createInstance(mergeConfig(axios.defaults, instanceConfig));
					};

					// Expose Cancel & CancelToken
					axios.Cancel = __webpack_require__(23);
					axios.CancelToken = __webpack_require__(24);
					axios.isCancel = __webpack_require__(9);

					// Expose all/spread
					axios.all = function all(promises) {
						return Promise.all(promises);
					};
					axios.spread = __webpack_require__(25);

					module.exports = axios;

					// Allow use of default import syntax in TypeScript
					module.exports.default = axios;


					/***/ }),
				/* 2 */
				/***/ (function(module, exports, __webpack_require__) {

					'use strict';

					var bind = __webpack_require__(3);

					/*global toString:true*/

					// utils is a library of generic helper functions non-specific to axios

					var toString = Object.prototype.toString;

					/**
					 * Determine if a value is an Array
					 *
					 * @param {Object} val The value to test
					 * @returns {boolean} True if value is an Array, otherwise false
					 */
					function isArray(val) {
						return toString.call(val) === '[object Array]';
					}

					/**
					 * Determine if a value is undefined
					 *
					 * @param {Object} val The value to test
					 * @returns {boolean} True if the value is undefined, otherwise false
					 */
					function isUndefined(val) {
						return typeof val === 'undefined';
					}

					/**
					 * Determine if a value is a Buffer
					 *
					 * @param {Object} val The value to test
					 * @returns {boolean} True if value is a Buffer, otherwise false
					 */
					function isBuffer(val) {
						return val !== null && !isUndefined(val) && val.constructor !== null && !isUndefined(val.constructor)
							&& typeof val.constructor.isBuffer === 'function' && val.constructor.isBuffer(val);
					}

					/**
					 * Determine if a value is an ArrayBuffer
					 *
					 * @param {Object} val The value to test
					 * @returns {boolean} True if value is an ArrayBuffer, otherwise false
					 */
					function isArrayBuffer(val) {
						return toString.call(val) === '[object ArrayBuffer]';
					}

					/**
					 * Determine if a value is a FormData
					 *
					 * @param {Object} val The value to test
					 * @returns {boolean} True if value is an FormData, otherwise false
					 */
					function isFormData(val) {
						return (typeof FormData !== 'undefined') && (val instanceof FormData);
					}

					/**
					 * Determine if a value is a view on an ArrayBuffer
					 *
					 * @param {Object} val The value to test
					 * @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false
					 */
					function isArrayBufferView(val) {
						var result;
						if ((typeof ArrayBuffer !== 'undefined') && (ArrayBuffer.isView)) {
							result = ArrayBuffer.isView(val);
						} else {
							result = (val) && (val.buffer) && (val.buffer instanceof ArrayBuffer);
						}
						return result;
					}

					/**
					 * Determine if a value is a String
					 *
					 * @param {Object} val The value to test
					 * @returns {boolean} True if value is a String, otherwise false
					 */
					function isString(val) {
						return typeof val === 'string';
					}

					/**
					 * Determine if a value is a Number
					 *
					 * @param {Object} val The value to test
					 * @returns {boolean} True if value is a Number, otherwise false
					 */
					function isNumber(val) {
						return typeof val === 'number';
					}

					/**
					 * Determine if a value is an Object
					 *
					 * @param {Object} val The value to test
					 * @returns {boolean} True if value is an Object, otherwise false
					 */
					function isObject(val) {
						return val !== null && typeof val === 'object';
					}

					/**
					 * Determine if a value is a plain Object
					 *
					 * @param {Object} val The value to test
					 * @return {boolean} True if value is a plain Object, otherwise false
					 */
					function isPlainObject(val) {
						if (toString.call(val) !== '[object Object]') {
							return false;
						}

						var prototype = Object.getPrototypeOf(val);
						return prototype === null || prototype === Object.prototype;
					}

					/**
					 * Determine if a value is a Date
					 *
					 * @param {Object} val The value to test
					 * @returns {boolean} True if value is a Date, otherwise false
					 */
					function isDate(val) {
						return toString.call(val) === '[object Date]';
					}

					/**
					 * Determine if a value is a File
					 *
					 * @param {Object} val The value to test
					 * @returns {boolean} True if value is a File, otherwise false
					 */
					function isFile(val) {
						return toString.call(val) === '[object File]';
					}

					/**
					 * Determine if a value is a Blob
					 *
					 * @param {Object} val The value to test
					 * @returns {boolean} True if value is a Blob, otherwise false
					 */
					function isBlob(val) {
						return toString.call(val) === '[object Blob]';
					}

					/**
					 * Determine if a value is a Function
					 *
					 * @param {Object} val The value to test
					 * @returns {boolean} True if value is a Function, otherwise false
					 */
					function isFunction(val) {
						return toString.call(val) === '[object Function]';
					}

					/**
					 * Determine if a value is a Stream
					 *
					 * @param {Object} val The value to test
					 * @returns {boolean} True if value is a Stream, otherwise false
					 */
					function isStream(val) {
						return isObject(val) && isFunction(val.pipe);
					}

					/**
					 * Determine if a value is a URLSearchParams object
					 *
					 * @param {Object} val The value to test
					 * @returns {boolean} True if value is a URLSearchParams object, otherwise false
					 */
					function isURLSearchParams(val) {
						return typeof URLSearchParams !== 'undefined' && val instanceof URLSearchParams;
					}

					/**
					 * Trim excess whitespace off the beginning and end of a string
					 *
					 * @param {String} str The String to trim
					 * @returns {String} The String freed of excess whitespace
					 */
					function trim(str) {
						return str.replace(/^\s*/, '').replace(/\s*$/, '');
					}

					/**
					 * Determine if we're running in a standard browser environment
					 *
					 * This allows axios to run in a web worker, and react-native.
					 * Both environments support XMLHttpRequest, but not fully standard globals.
					 *
					 * web workers:
					 *  typeof window -> undefined
					 *  typeof document -> undefined
					 *
					 * react-native:
					 *  navigator.product -> 'ReactNative'
					 * nativescript
					 *  navigator.product -> 'NativeScript' or 'NS'
					 */
					function isStandardBrowserEnv() {
						if (typeof navigator !== 'undefined' && (navigator.product === 'ReactNative' ||
							navigator.product === 'NativeScript' ||
							navigator.product === 'NS')) {
							return false;
						}
						return (
							typeof window !== 'undefined' &&
							typeof document !== 'undefined'
						);
					}

					/**
					 * Iterate over an Array or an Object invoking a function for each item.
					 *
					 * If `obj` is an Array callback will be called passing
					 * the value, index, and complete array for each item.
					 *
					 * If 'obj' is an Object callback will be called passing
					 * the value, key, and complete object for each property.
					 *
					 * @param {Object|Array} obj The object to iterate
					 * @param {Function} fn The callback to invoke for each item
					 */
					function forEach(obj, fn) {
						// Don't bother if no value provided
						if (obj === null || typeof obj === 'undefined') {
							return;
						}

						// Force an array if not already something iterable
						if (typeof obj !== 'object') {
							/*eslint no-param-reassign:0*/
							obj = [obj];
						}

						if (isArray(obj)) {
							// Iterate over array values
							for (var i = 0, l = obj.length; i < l; i++) {
								fn.call(null, obj[i], i, obj);
							}
						} else {
							// Iterate over object keys
							for (var key in obj) {
								if (Object.prototype.hasOwnProperty.call(obj, key)) {
									fn.call(null, obj[key], key, obj);
								}
							}
						}
					}

					/**
					 * Accepts varargs expecting each argument to be an object, then
					 * immutably merges the properties of each object and returns result.
					 *
					 * When multiple objects contain the same key the later object in
					 * the arguments list will take precedence.
					 *
					 * Example:
					 *
					 * ```js
					 * var result = merge({foo: 123}, {foo: 456});
					 * console.log(result.foo); // outputs 456
					 * ```
					 *
					 * @param {Object} obj1 Object to merge
					 * @returns {Object} Result of all merge properties
					 */
					function merge(/* obj1, obj2, obj3, ... */) {
						var result = {};
						function assignValue(val, key) {
							if (isPlainObject(result[key]) && isPlainObject(val)) {
								result[key] = merge(result[key], val);
							} else if (isPlainObject(val)) {
								result[key] = merge({}, val);
							} else if (isArray(val)) {
								result[key] = val.slice();
							} else {
								result[key] = val;
							}
						}

						for (var i = 0, l = arguments.length; i < l; i++) {
							forEach(arguments[i], assignValue);
						}
						return result;
					}

					/**
					 * Extends object a by mutably adding to it the properties of object b.
					 *
					 * @param {Object} a The object to be extended
					 * @param {Object} b The object to copy properties from
					 * @param {Object} thisArg The object to bind function to
					 * @return {Object} The resulting value of object a
					 */
					function extend(a, b, thisArg) {
						forEach(b, function assignValue(val, key) {
							if (thisArg && typeof val === 'function') {
								a[key] = bind(val, thisArg);
							} else {
								a[key] = val;
							}
						});
						return a;
					}

					/**
					 * Remove byte order marker. This catches EF BB BF (the UTF-8 BOM)
					 *
					 * @param {string} content with BOM
					 * @return {string} content value without BOM
					 */
					function stripBOM(content) {
						if (content.charCodeAt(0) === 0xFEFF) {
							content = content.slice(1);
						}
						return content;
					}

					module.exports = {
						isArray: isArray,
						isArrayBuffer: isArrayBuffer,
						isBuffer: isBuffer,
						isFormData: isFormData,
						isArrayBufferView: isArrayBufferView,
						isString: isString,
						isNumber: isNumber,
						isObject: isObject,
						isPlainObject: isPlainObject,
						isUndefined: isUndefined,
						isDate: isDate,
						isFile: isFile,
						isBlob: isBlob,
						isFunction: isFunction,
						isStream: isStream,
						isURLSearchParams: isURLSearchParams,
						isStandardBrowserEnv: isStandardBrowserEnv,
						forEach: forEach,
						merge: merge,
						extend: extend,
						trim: trim,
						stripBOM: stripBOM
					};


					/***/ }),
				/* 3 */
				/***/ (function(module, exports) {

					'use strict';

					module.exports = function bind(fn, thisArg) {
						return function wrap() {
							var args = new Array(arguments.length);
							for (var i = 0; i < args.length; i++) {
								args[i] = arguments[i];
							}
							return fn.apply(thisArg, args);
						};
					};


					/***/ }),
				/* 4 */
				/***/ (function(module, exports, __webpack_require__) {

					'use strict';

					var utils = __webpack_require__(2);
					var buildURL = __webpack_require__(5);
					var InterceptorManager = __webpack_require__(6);
					var dispatchRequest = __webpack_require__(7);
					var mergeConfig = __webpack_require__(22);

					/**
					 * Create a new instance of Axios
					 *
					 * @param {Object} instanceConfig The default config for the instance
					 */
					function Axios(instanceConfig) {
						this.defaults = instanceConfig;
						this.interceptors = {
							request: new InterceptorManager(),
							response: new InterceptorManager()
						};
					}

					/**
					 * Dispatch a request
					 *
					 * @param {Object} config The config specific for this request (merged with this.defaults)
					 */
					Axios.prototype.request = function request(config) {
						/*eslint no-param-reassign:0*/
						// Allow for axios('example/url'[, config]) a la fetch API
						if (typeof config === 'string') {
							config = arguments[1] || {};
							config.url = arguments[0];
						} else {
							config = config || {};
						}

						config = mergeConfig(this.defaults, config);

						// Set config.method
						if (config.method) {
							config.method = config.method.toLowerCase();
						} else if (this.defaults.method) {
							config.method = this.defaults.method.toLowerCase();
						} else {
							config.method = 'get';
						}

						// Hook up interceptors middleware
						var chain = [dispatchRequest, undefined];
						var promise = Promise.resolve(config);

						this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {
							chain.unshift(interceptor.fulfilled, interceptor.rejected);
						});

						this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {
							chain.push(interceptor.fulfilled, interceptor.rejected);
						});

						while (chain.length) {
							promise = promise.then(chain.shift(), chain.shift());
						}

						return promise;
					};

					Axios.prototype.getUri = function getUri(config) {
						config = mergeConfig(this.defaults, config);
						return buildURL(config.url, config.params, config.paramsSerializer).replace(/^\?/, '');
					};

					// Provide aliases for supported request methods
					utils.forEach(['delete', 'get', 'head', 'options'], function forEachMethodNoData(method) {
						/*eslint func-names:0*/
						Axios.prototype[method] = function(url, config) {
							return this.request(mergeConfig(config || {}, {
								method: method,
								url: url,
								data: (config || {}).data
							}));
						};
					});

					utils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {
						/*eslint func-names:0*/
						Axios.prototype[method] = function(url, data, config) {
							return this.request(mergeConfig(config || {}, {
								method: method,
								url: url,
								data: data
							}));
						};
					});

					module.exports = Axios;


					/***/ }),
				/* 5 */
				/***/ (function(module, exports, __webpack_require__) {

					'use strict';

					var utils = __webpack_require__(2);

					function encode(val) {
						return encodeURIComponent(val).
						replace(/%3A/gi, ':').
						replace(/%24/g, '$').
						replace(/%2C/gi, ',').
						replace(/%20/g, '+').
						replace(/%5B/gi, '[').
						replace(/%5D/gi, ']');
					}

					/**
					 * Build a URL by appending params to the end
					 *
					 * @param {string} url The base of the url (e.g., http://www.google.com)
					 * @param {object} [params] The params to be appended
					 * @returns {string} The formatted url
					 */
					module.exports = function buildURL(url, params, paramsSerializer) {
						/*eslint no-param-reassign:0*/
						if (!params) {
							return url;
						}

						var serializedParams;
						if (paramsSerializer) {
							serializedParams = paramsSerializer(params);
						} else if (utils.isURLSearchParams(params)) {
							serializedParams = params.toString();
						} else {
							var parts = [];

							utils.forEach(params, function serialize(val, key) {
								if (val === null || typeof val === 'undefined') {
									return;
								}

								if (utils.isArray(val)) {
									key = key + '[]';
								} else {
									val = [val];
								}

								utils.forEach(val, function parseValue(v) {
									if (utils.isDate(v)) {
										v = v.toISOString();
									} else if (utils.isObject(v)) {
										v = JSON.stringify(v);
									}
									parts.push(encode(key) + '=' + encode(v));
								});
							});

							serializedParams = parts.join('&');
						}

						if (serializedParams) {
							var hashmarkIndex = url.indexOf('#');
							if (hashmarkIndex !== -1) {
								url = url.slice(0, hashmarkIndex);
							}

							url += (url.indexOf('?') === -1 ? '?' : '&') + serializedParams;
						}

						return url;
					};


					/***/ }),
				/* 6 */
				/***/ (function(module, exports, __webpack_require__) {

					'use strict';

					var utils = __webpack_require__(2);

					function InterceptorManager() {
						this.handlers = [];
					}

					/**
					 * Add a new interceptor to the stack
					 *
					 * @param {Function} fulfilled The function to handle `then` for a `Promise`
					 * @param {Function} rejected The function to handle `reject` for a `Promise`
					 *
					 * @return {Number} An ID used to remove interceptor later
					 */
					InterceptorManager.prototype.use = function use(fulfilled, rejected) {
						this.handlers.push({
							fulfilled: fulfilled,
							rejected: rejected
						});
						return this.handlers.length - 1;
					};

					/**
					 * Remove an interceptor from the stack
					 *
					 * @param {Number} id The ID that was returned by `use`
					 */
					InterceptorManager.prototype.eject = function eject(id) {
						if (this.handlers[id]) {
							this.handlers[id] = null;
						}
					};

					/**
					 * Iterate over all the registered interceptors
					 *
					 * This method is particularly useful for skipping over any
					 * interceptors that may have become `null` calling `eject`.
					 *
					 * @param {Function} fn The function to call for each interceptor
					 */
					InterceptorManager.prototype.forEach = function forEach(fn) {
						utils.forEach(this.handlers, function forEachHandler(h) {
							if (h !== null) {
								fn(h);
							}
						});
					};

					module.exports = InterceptorManager;


					/***/ }),
				/* 7 */
				/***/ (function(module, exports, __webpack_require__) {

					'use strict';

					var utils = __webpack_require__(2);
					var transformData = __webpack_require__(8);
					var isCancel = __webpack_require__(9);
					var defaults = __webpack_require__(10);

					/**
					 * Throws a `Cancel` if cancellation has been requested.
					 */
					function throwIfCancellationRequested(config) {
						if (config.cancelToken) {
							config.cancelToken.throwIfRequested();
						}
					}

					/**
					 * Dispatch a request to the server using the configured adapter.
					 *
					 * @param {object} config The config that is to be used for the request
					 * @returns {Promise} The Promise to be fulfilled
					 */
					module.exports = function dispatchRequest(config) {
						throwIfCancellationRequested(config);

						// Ensure headers exist
						config.headers = config.headers || {};

						// Transform request data
						config.data = transformData(
							config.data,
							config.headers,
							config.transformRequest
						);

						// Flatten headers
						config.headers = utils.merge(
							config.headers.common || {},
							config.headers[config.method] || {},
							config.headers
						);

						utils.forEach(
							['delete', 'get', 'head', 'post', 'put', 'patch', 'common'],
							function cleanHeaderConfig(method) {
								delete config.headers[method];
							}
						);

						var adapter = config.adapter || defaults.adapter;

						return adapter(config).then(function onAdapterResolution(response) {
							throwIfCancellationRequested(config);

							// Transform response data
							response.data = transformData(
								response.data,
								response.headers,
								config.transformResponse
							);

							return response;
						}, function onAdapterRejection(reason) {
							if (!isCancel(reason)) {
								throwIfCancellationRequested(config);

								// Transform response data
								if (reason && reason.response) {
									reason.response.data = transformData(
										reason.response.data,
										reason.response.headers,
										config.transformResponse
									);
								}
							}

							return Promise.reject(reason);
						});
					};


					/***/ }),
				/* 8 */
				/***/ (function(module, exports, __webpack_require__) {

					'use strict';

					var utils = __webpack_require__(2);

					/**
					 * Transform the data for a request or a response
					 *
					 * @param {Object|String} data The data to be transformed
					 * @param {Array} headers The headers for the request or response
					 * @param {Array|Function} fns A single function or Array of functions
					 * @returns {*} The resulting transformed data
					 */
					module.exports = function transformData(data, headers, fns) {
						/*eslint no-param-reassign:0*/
						utils.forEach(fns, function transform(fn) {
							data = fn(data, headers);
						});

						return data;
					};


					/***/ }),
				/* 9 */
				/***/ (function(module, exports) {

					'use strict';

					module.exports = function isCancel(value) {
						return !!(value && value.__CANCEL__);
					};


					/***/ }),
				/* 10 */
				/***/ (function(module, exports, __webpack_require__) {

					'use strict';

					var utils = __webpack_require__(2);
					var normalizeHeaderName = __webpack_require__(11);

					var DEFAULT_CONTENT_TYPE = {
						'Content-Type': 'application/x-www-form-urlencoded'
					};

					function setContentTypeIfUnset(headers, value) {
						if (!utils.isUndefined(headers) && utils.isUndefined(headers['Content-Type'])) {
							headers['Content-Type'] = value;
						}
					}

					function getDefaultAdapter() {
						var adapter;
						if (typeof XMLHttpRequest !== 'undefined') {
							// For browsers use XHR adapter
							adapter = __webpack_require__(12);
						} else if (typeof process !== 'undefined' && Object.prototype.toString.call(process) === '[object process]') {
							// For node use HTTP adapter
							adapter = __webpack_require__(12);
						}
						return adapter;
					}

					var defaults = {
						adapter: getDefaultAdapter(),

						transformRequest: [function transformRequest(data, headers) {
							normalizeHeaderName(headers, 'Accept');
							normalizeHeaderName(headers, 'Content-Type');
							if (utils.isFormData(data) ||
								utils.isArrayBuffer(data) ||
								utils.isBuffer(data) ||
								utils.isStream(data) ||
								utils.isFile(data) ||
								utils.isBlob(data)
							) {
								return data;
							}
							if (utils.isArrayBufferView(data)) {
								return data.buffer;
							}
							if (utils.isURLSearchParams(data)) {
								setContentTypeIfUnset(headers, 'application/x-www-form-urlencoded;charset=utf-8');
								return data.toString();
							}
							if (utils.isObject(data)) {
								setContentTypeIfUnset(headers, 'application/json;charset=utf-8');
								return JSON.stringify(data);
							}
							return data;
						}],

						transformResponse: [function transformResponse(data) {
							/*eslint no-param-reassign:0*/
							if (typeof data === 'string') {
								try {
									data = JSON.parse(data);
								} catch (e) { /* Ignore */ }
							}
							return data;
						}],

						/**
						 * A timeout in milliseconds to abort a request. If set to 0 (default) a
						 * timeout is not created.
						 */
						timeout: 0,

						xsrfCookieName: 'XSRF-TOKEN',
						xsrfHeaderName: 'X-XSRF-TOKEN',

						maxContentLength: -1,
						maxBodyLength: -1,

						validateStatus: function validateStatus(status) {
							return status >= 200 && status < 300;
						}
					};

					defaults.headers = {
						common: {
							'Accept': 'application/json, text/plain, */*'
						}
					};

					utils.forEach(['delete', 'get', 'head'], function forEachMethodNoData(method) {
						defaults.headers[method] = {};
					});

					utils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {
						defaults.headers[method] = utils.merge(DEFAULT_CONTENT_TYPE);
					});

					module.exports = defaults;


					/***/ }),
				/* 11 */
				/***/ (function(module, exports, __webpack_require__) {

					'use strict';

					var utils = __webpack_require__(2);

					module.exports = function normalizeHeaderName(headers, normalizedName) {
						utils.forEach(headers, function processHeader(value, name) {
							if (name !== normalizedName && name.toUpperCase() === normalizedName.toUpperCase()) {
								headers[normalizedName] = value;
								delete headers[name];
							}
						});
					};


					/***/ }),
				/* 12 */
				/***/ (function(module, exports, __webpack_require__) {

					'use strict';

					var utils = __webpack_require__(2);
					var settle = __webpack_require__(13);
					var cookies = __webpack_require__(16);
					var buildURL = __webpack_require__(5);
					var buildFullPath = __webpack_require__(17);
					var parseHeaders = __webpack_require__(20);
					var isURLSameOrigin = __webpack_require__(21);
					var createError = __webpack_require__(14);

					module.exports = function xhrAdapter(config) {
						return new Promise(function dispatchXhrRequest(resolve, reject) {
							var requestData = config.data;
							var requestHeaders = config.headers;

							if (utils.isFormData(requestData)) {
								delete requestHeaders['Content-Type']; // Let the browser set it
							}

							var request = new XMLHttpRequest();

							// HTTP basic authentication
							if (config.auth) {
								var username = config.auth.username || '';
								var password = config.auth.password ? unescape(encodeURIComponent(config.auth.password)) : '';
								requestHeaders.Authorization = 'Basic ' + btoa(username + ':' + password);
							}

							var fullPath = buildFullPath(config.baseURL, config.url);
							request.open(config.method.toUpperCase(), buildURL(fullPath, config.params, config.paramsSerializer), true);

							// Set the request timeout in MS
							request.timeout = config.timeout;

							// Listen for ready state
							request.onreadystatechange = function handleLoad() {
								if (!request || request.readyState !== 4) {
									return;
								}

								// The request errored out and we didn't get a response, this will be
								// handled by onerror instead
								// With one exception: request that using file: protocol, most browsers
								// will return status as 0 even though it's a successful request
								if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf('file:') === 0)) {
									return;
								}

								// Prepare the response
								var responseHeaders = 'getAllResponseHeaders' in request ? parseHeaders(request.getAllResponseHeaders()) : null;
								var responseData = !config.responseType || config.responseType === 'text' ? request.responseText : request.response;
								var response = {
									data: responseData,
									status: request.status,
									statusText: request.statusText,
									headers: responseHeaders,
									config: config,
									request: request
								};

								settle(resolve, reject, response);

								// Clean up request
								request = null;
							};

							// Handle browser request cancellation (as opposed to a manual cancellation)
							request.onabort = function handleAbort() {
								if (!request) {
									return;
								}

								reject(createError('Request aborted', config, 'ECONNABORTED', request));

								// Clean up request
								request = null;
							};

							// Handle low level network errors
							request.onerror = function handleError() {
								// Real errors are hidden from us by the browser
								// onerror should only fire if it's a network error
								reject(createError('Network Error', config, null, request));

								// Clean up request
								request = null;
							};

							// Handle timeout
							request.ontimeout = function handleTimeout() {
								var timeoutErrorMessage = 'timeout of ' + config.timeout + 'ms exceeded';
								if (config.timeoutErrorMessage) {
									timeoutErrorMessage = config.timeoutErrorMessage;
								}
								reject(createError(timeoutErrorMessage, config, 'ECONNABORTED',
									request));

								// Clean up request
								request = null;
							};

							// Add xsrf header
							// This is only done if running in a standard browser environment.
							// Specifically not if we're in a web worker, or react-native.
							if (utils.isStandardBrowserEnv()) {
								// Add xsrf header
								var xsrfValue = (config.withCredentials || isURLSameOrigin(fullPath)) && config.xsrfCookieName ?
									cookies.read(config.xsrfCookieName) :
									undefined;

								if (xsrfValue) {
									requestHeaders[config.xsrfHeaderName] = xsrfValue;
								}
							}

							// Add headers to the request
							if ('setRequestHeader' in request) {
								utils.forEach(requestHeaders, function setRequestHeader(val, key) {
									if (typeof requestData === 'undefined' && key.toLowerCase() === 'content-type') {
										// Remove Content-Type if data is undefined
										delete requestHeaders[key];
									} else {
										// Otherwise add header to the request
										request.setRequestHeader(key, val);
									}
								});
							}

							// Add withCredentials to request if needed
							if (!utils.isUndefined(config.withCredentials)) {
								request.withCredentials = !!config.withCredentials;
							}

							// Add responseType to request if needed
							if (config.responseType) {
								try {
									request.responseType = config.responseType;
								} catch (e) {
									// Expected DOMException thrown by browsers not compatible XMLHttpRequest Level 2.
									// But, this can be suppressed for 'json' type as it can be parsed by default 'transformResponse' function.
									if (config.responseType !== 'json') {
										throw e;
									}
								}
							}

							// Handle progress if needed
							if (typeof config.onDownloadProgress === 'function') {
								request.addEventListener('progress', config.onDownloadProgress);
							}

							// Not all browsers support upload events
							if (typeof config.onUploadProgress === 'function' && request.upload) {
								request.upload.addEventListener('progress', config.onUploadProgress);
							}

							if (config.cancelToken) {
								// Handle cancellation
								config.cancelToken.promise.then(function onCanceled(cancel) {
									if (!request) {
										return;
									}

									request.abort();
									reject(cancel);
									// Clean up request
									request = null;
								});
							}

							if (!requestData) {
								requestData = null;
							}

							// Send the request
							request.send(requestData);
						});
					};


					/***/ }),
				/* 13 */
				/***/ (function(module, exports, __webpack_require__) {

					'use strict';

					var createError = __webpack_require__(14);

					/**
					 * Resolve or reject a Promise based on response status.
					 *
					 * @param {Function} resolve A function that resolves the promise.
					 * @param {Function} reject A function that rejects the promise.
					 * @param {object} response The response.
					 */
					module.exports = function settle(resolve, reject, response) {
						var validateStatus = response.config.validateStatus;
						if (!response.status || !validateStatus || validateStatus(response.status)) {
							resolve(response);
						} else {
							reject(createError(
								'Request failed with status code ' + response.status,
								response.config,
								null,
								response.request,
								response
							));
						}
					};


					/***/ }),
				/* 14 */
				/***/ (function(module, exports, __webpack_require__) {

					'use strict';

					var enhanceError = __webpack_require__(15);

					/**
					 * Create an Error with the specified message, config, error code, request and response.
					 *
					 * @param {string} message The error message.
					 * @param {Object} config The config.
					 * @param {string} [code] The error code (for example, 'ECONNABORTED').
					 * @param {Object} [request] The request.
					 * @param {Object} [response] The response.
					 * @returns {Error} The created error.
					 */
					module.exports = function createError(message, config, code, request, response) {
						var error = new Error(message);
						return enhanceError(error, config, code, request, response);
					};


					/***/ }),
				/* 15 */
				/***/ (function(module, exports) {

					'use strict';

					/**
					 * Update an Error with the specified config, error code, and response.
					 *
					 * @param {Error} error The error to update.
					 * @param {Object} config The config.
					 * @param {string} [code] The error code (for example, 'ECONNABORTED').
					 * @param {Object} [request] The request.
					 * @param {Object} [response] The response.
					 * @returns {Error} The error.
					 */
					module.exports = function enhanceError(error, config, code, request, response) {
						error.config = config;
						if (code) {
							error.code = code;
						}

						error.request = request;
						error.response = response;
						error.isAxiosError = true;

						error.toJSON = function toJSON() {
							return {
								// Standard
								message: this.message,
								name: this.name,
								// Microsoft
								description: this.description,
								number: this.number,
								// Mozilla
								fileName: this.fileName,
								lineNumber: this.lineNumber,
								columnNumber: this.columnNumber,
								stack: this.stack,
								// Axios
								config: this.config,
								code: this.code
							};
						};
						return error;
					};


					/***/ }),
				/* 16 */
				/***/ (function(module, exports, __webpack_require__) {

					'use strict';

					var utils = __webpack_require__(2);

					module.exports = (
						utils.isStandardBrowserEnv() ?

							// Standard browser envs support document.cookie
							(function standardBrowserEnv() {
								return {
									write: function write(name, value, expires, path, domain, secure) {
										var cookie = [];
										cookie.push(name + '=' + encodeURIComponent(value));

										if (utils.isNumber(expires)) {
											cookie.push('expires=' + new Date(expires).toGMTString());
										}

										if (utils.isString(path)) {
											cookie.push('path=' + path);
										}

										if (utils.isString(domain)) {
											cookie.push('domain=' + domain);
										}

										if (secure === true) {
											cookie.push('secure');
										}

										document.cookie = cookie.join('; ');
									},

									read: function read(name) {
										var match = document.cookie.match(new RegExp('(^|;\\s*)(' + name + ')=([^;]*)'));
										return (match ? decodeURIComponent(match[3]) : null);
									},

									remove: function remove(name) {
										this.write(name, '', Date.now() - 86400000);
									}
								};
							})() :

							// Non standard browser env (web workers, react-native) lack needed support.
							(function nonStandardBrowserEnv() {
								return {
									write: function write() {},
									read: function read() { return null; },
									remove: function remove() {}
								};
							})()
					);


					/***/ }),
				/* 17 */
				/***/ (function(module, exports, __webpack_require__) {

					'use strict';

					var isAbsoluteURL = __webpack_require__(18);
					var combineURLs = __webpack_require__(19);

					/**
					 * Creates a new URL by combining the baseURL with the requestedURL,
					 * only when the requestedURL is not already an absolute URL.
					 * If the requestURL is absolute, this function returns the requestedURL untouched.
					 *
					 * @param {string} baseURL The base URL
					 * @param {string} requestedURL Absolute or relative URL to combine
					 * @returns {string} The combined full path
					 */
					module.exports = function buildFullPath(baseURL, requestedURL) {
						if (baseURL && !isAbsoluteURL(requestedURL)) {
							return combineURLs(baseURL, requestedURL);
						}
						return requestedURL;
					};


					/***/ }),
				/* 18 */
				/***/ (function(module, exports) {

					'use strict';

					/**
					 * Determines whether the specified URL is absolute
					 *
					 * @param {string} url The URL to test
					 * @returns {boolean} True if the specified URL is absolute, otherwise false
					 */
					module.exports = function isAbsoluteURL(url) {
						// A URL is considered absolute if it begins with "<scheme>://" or "//" (protocol-relative URL).
						// RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed
						// by any combination of letters, digits, plus, period, or hyphen.
						return /^([a-z][a-z\d\+\-\.]*:)?\/\//i.test(url);
					};


					/***/ }),
				/* 19 */
				/***/ (function(module, exports) {

					'use strict';

					/**
					 * Creates a new URL by combining the specified URLs
					 *
					 * @param {string} baseURL The base URL
					 * @param {string} relativeURL The relative URL
					 * @returns {string} The combined URL
					 */
					module.exports = function combineURLs(baseURL, relativeURL) {
						return relativeURL
							? baseURL.replace(/\/+$/, '') + '/' + relativeURL.replace(/^\/+/, '')
							: baseURL;
					};


					/***/ }),
				/* 20 */
				/***/ (function(module, exports, __webpack_require__) {

					'use strict';

					var utils = __webpack_require__(2);

					// Headers whose duplicates are ignored by node
					// c.f. https://nodejs.org/api/http.html#http_message_headers
					var ignoreDuplicateOf = [
						'age', 'authorization', 'content-length', 'content-type', 'etag',
						'expires', 'from', 'host', 'if-modified-since', 'if-unmodified-since',
						'last-modified', 'location', 'max-forwards', 'proxy-authorization',
						'referer', 'retry-after', 'user-agent'
					];

					/**
					 * Parse headers into an object
					 *
					 * ```
					 * Date: Wed, 27 Aug 2014 08:58:49 GMT
					 * Content-Type: application/json
					 * Connection: keep-alive
					 * Transfer-Encoding: chunked
					 * ```
					 *
					 * @param {String} headers Headers needing to be parsed
					 * @returns {Object} Headers parsed into an object
					 */
					module.exports = function parseHeaders(headers) {
						var parsed = {};
						var key;
						var val;
						var i;

						if (!headers) { return parsed; }

						utils.forEach(headers.split('\n'), function parser(line) {
							i = line.indexOf(':');
							key = utils.trim(line.substr(0, i)).toLowerCase();
							val = utils.trim(line.substr(i + 1));

							if (key) {
								if (parsed[key] && ignoreDuplicateOf.indexOf(key) >= 0) {
									return;
								}
								if (key === 'set-cookie') {
									parsed[key] = (parsed[key] ? parsed[key] : []).concat([val]);
								} else {
									parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;
								}
							}
						});

						return parsed;
					};


					/***/ }),
				/* 21 */
				/***/ (function(module, exports, __webpack_require__) {

					'use strict';

					var utils = __webpack_require__(2);

					module.exports = (
						utils.isStandardBrowserEnv() ?

							// Standard browser envs have full support of the APIs needed to test
							// whether the request URL is of the same origin as current location.
							(function standardBrowserEnv() {
								var msie = /(msie|trident)/i.test(navigator.userAgent);
								var urlParsingNode = document.createElement('a');
								var originURL;

								/**
								 * Parse a URL to discover it's components
								 *
								 * @param {String} url The URL to be parsed
								 * @returns {Object}
								 */
								function resolveURL(url) {
									var href = url;

									if (msie) {
										// IE needs attribute set twice to normalize properties
										urlParsingNode.setAttribute('href', href);
										href = urlParsingNode.href;
									}

									urlParsingNode.setAttribute('href', href);

									// urlParsingNode provides the UrlUtils interface - http://url.spec.whatwg.org/#urlutils
									return {
										href: urlParsingNode.href,
										protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, '') : '',
										host: urlParsingNode.host,
										search: urlParsingNode.search ? urlParsingNode.search.replace(/^\?/, '') : '',
										hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, '') : '',
										hostname: urlParsingNode.hostname,
										port: urlParsingNode.port,
										pathname: (urlParsingNode.pathname.charAt(0) === '/') ?
											urlParsingNode.pathname :
											'/' + urlParsingNode.pathname
									};
								}

								originURL = resolveURL(window.location.href);

								/**
								 * Determine if a URL shares the same origin as the current location
								 *
								 * @param {String} requestURL The URL to test
								 * @returns {boolean} True if URL shares the same origin, otherwise false
								 */
								return function isURLSameOrigin(requestURL) {
									var parsed = (utils.isString(requestURL)) ? resolveURL(requestURL) : requestURL;
									return (parsed.protocol === originURL.protocol &&
										parsed.host === originURL.host);
								};
							})() :

							// Non standard browser envs (web workers, react-native) lack needed support.
							(function nonStandardBrowserEnv() {
								return function isURLSameOrigin() {
									return true;
								};
							})()
					);


					/***/ }),
				/* 22 */
				/***/ (function(module, exports, __webpack_require__) {

					'use strict';

					var utils = __webpack_require__(2);

					/**
					 * Config-specific merge-function which creates a new config-object
					 * by merging two configuration objects together.
					 *
					 * @param {Object} config1
					 * @param {Object} config2
					 * @returns {Object} New object resulting from merging config2 to config1
					 */
					module.exports = function mergeConfig(config1, config2) {
						// eslint-disable-next-line no-param-reassign
						config2 = config2 || {};
						var config = {};

						var valueFromConfig2Keys = ['url', 'method', 'data'];
						var mergeDeepPropertiesKeys = ['headers', 'auth', 'proxy', 'params'];
						var defaultToConfig2Keys = [
							'baseURL', 'transformRequest', 'transformResponse', 'paramsSerializer',
							'timeout', 'timeoutMessage', 'withCredentials', 'adapter', 'responseType', 'xsrfCookieName',
							'xsrfHeaderName', 'onUploadProgress', 'onDownloadProgress', 'decompress',
							'maxContentLength', 'maxBodyLength', 'maxRedirects', 'transport', 'httpAgent',
							'httpsAgent', 'cancelToken', 'socketPath', 'responseEncoding'
						];
						var directMergeKeys = ['validateStatus'];

						function getMergedValue(target, source) {
							if (utils.isPlainObject(target) && utils.isPlainObject(source)) {
								return utils.merge(target, source);
							} else if (utils.isPlainObject(source)) {
								return utils.merge({}, source);
							} else if (utils.isArray(source)) {
								return source.slice();
							}
							return source;
						}

						function mergeDeepProperties(prop) {
							if (!utils.isUndefined(config2[prop])) {
								config[prop] = getMergedValue(config1[prop], config2[prop]);
							} else if (!utils.isUndefined(config1[prop])) {
								config[prop] = getMergedValue(undefined, config1[prop]);
							}
						}

						utils.forEach(valueFromConfig2Keys, function valueFromConfig2(prop) {
							if (!utils.isUndefined(config2[prop])) {
								config[prop] = getMergedValue(undefined, config2[prop]);
							}
						});

						utils.forEach(mergeDeepPropertiesKeys, mergeDeepProperties);

						utils.forEach(defaultToConfig2Keys, function defaultToConfig2(prop) {
							if (!utils.isUndefined(config2[prop])) {
								config[prop] = getMergedValue(undefined, config2[prop]);
							} else if (!utils.isUndefined(config1[prop])) {
								config[prop] = getMergedValue(undefined, config1[prop]);
							}
						});

						utils.forEach(directMergeKeys, function merge(prop) {
							if (prop in config2) {
								config[prop] = getMergedValue(config1[prop], config2[prop]);
							} else if (prop in config1) {
								config[prop] = getMergedValue(undefined, config1[prop]);
							}
						});

						var axiosKeys = valueFromConfig2Keys
							.concat(mergeDeepPropertiesKeys)
							.concat(defaultToConfig2Keys)
							.concat(directMergeKeys);

						var otherKeys = Object
							.keys(config1)
							.concat(Object.keys(config2))
							.filter(function filterAxiosKeys(key) {
								return axiosKeys.indexOf(key) === -1;
							});

						utils.forEach(otherKeys, mergeDeepProperties);

						return config;
					};


					/***/ }),
				/* 23 */
				/***/ (function(module, exports) {

					'use strict';

					/**
					 * A `Cancel` is an object that is thrown when an operation is canceled.
					 *
					 * @class
					 * @param {string=} message The message.
					 */
					function Cancel(message) {
						this.message = message;
					}

					Cancel.prototype.toString = function toString() {
						return 'Cancel' + (this.message ? ': ' + this.message : '');
					};

					Cancel.prototype.__CANCEL__ = true;

					module.exports = Cancel;


					/***/ }),
				/* 24 */
				/***/ (function(module, exports, __webpack_require__) {

					'use strict';

					var Cancel = __webpack_require__(23);

					/**
					 * A `CancelToken` is an object that can be used to request cancellation of an operation.
					 *
					 * @class
					 * @param {Function} executor The executor function.
					 */
					function CancelToken(executor) {
						if (typeof executor !== 'function') {
							throw new TypeError('executor must be a function.');
						}

						var resolvePromise;
						this.promise = new Promise(function promiseExecutor(resolve) {
							resolvePromise = resolve;
						});

						var token = this;
						executor(function cancel(message) {
							if (token.reason) {
								// Cancellation has already been requested
								return;
							}

							token.reason = new Cancel(message);
							resolvePromise(token.reason);
						});
					}

					/**
					 * Throws a `Cancel` if cancellation has been requested.
					 */
					CancelToken.prototype.throwIfRequested = function throwIfRequested() {
						if (this.reason) {
							throw this.reason;
						}
					};

					/**
					 * Returns an object that contains a new `CancelToken` and a function that, when called,
					 * cancels the `CancelToken`.
					 */
					CancelToken.source = function source() {
						var cancel;
						var token = new CancelToken(function executor(c) {
							cancel = c;
						});
						return {
							token: token,
							cancel: cancel
						};
					};

					module.exports = CancelToken;


					/***/ }),
				/* 25 */
				/***/ (function(module, exports) {

					'use strict';

					/**
					 * Syntactic sugar for invoking a function and expanding an array for arguments.
					 *
					 * Common use case would be to use `Function.prototype.apply`.
					 *
					 *  ```js
					 *  function f(x, y, z) {}
					 *  var args = [1, 2, 3];
					 *  f.apply(null, args);
					 *  ```
					 *
					 * With `spread` this example can be re-written.
					 *
					 *  ```js
					 *  spread(function(x, y, z) {})([1, 2, 3]);
					 *  ```
					 *
					 * @param {Function} callback
					 * @returns {Function}
					 */
					module.exports = function spread(callback) {
						return function wrap(arr) {
							return callback.apply(null, arr);
						};
					};


					/***/ })
				/******/ ])
	});
//# sourceMappingURL=axios.map

	//加载store模块
	var store = layui.store;
	axios.interceptors.request.use(function(config){
		//给每个请求加上token（如果token存在）
		if(store.getToken()){
			config.headers.token=store.getToken();
		}
		return config;
	},function(error){
		return Promise.reject(error);
	});


	axios.interceptors.response.use(function(response){
		if(response.status==200){
			//获取响应的头部
			if(response.headers.token){
				//将响应的token设置到客户端中，达到更新token的效果
				// console.log(response.headers.token)
				// console.log(response.headers.token)
				// console.log(response.headers.token)

				store.setToken(response.headers.token);
			}
			//layer.msg(response.headers.token);
			const res = response.data;
			return res;
			// if(res.code==200){ //后端返回的数据为200的时候为正常数据
			// 	return res;
			// }else if(res.code==400){//token过时
			// 	window.location.href = 'login.html';
			// 	return ;
			// }else{
			// 	return Promise.reject(res.msg);
			// }
		}else{
			return Promise.reject(response.statusText);
		}
	},function(error){
		return Promise.reject(error);
	});
	axios.defaults.baseURL="http://localhost:8080";
	axios.defaults.headers.post['Content-Type'] = 'application/x-www-form-urlencoded';
//输出axios
	exports('axios', axios);
});
